파이썬 클린코드 | 9장 일반적인 디자인 패턴

실전속의 디자인 패턴

구조(structural) 패턴

어댑터 패턴

• 기존 클래스를 상속받는 새로운 클래스를 만드는 방법

from _adapter_base import UsernameLookup # 외부의 코드 임포트

class UserSoirce(UsernameLookup): # 상속을 통해 새로운 클래스 생성
	def fetch(self, user_id, username): # 해당 메서드 실행
		user_namespace = self._adapt_arguments(user_id, username)
		return self.search(user_namespace) # search 라는 외부 의존성 객체 존재

	@staticmethod
	def _adapt_arguments(user_id, username):
		return f"{user_id}:{username}"

• 상속을 하면 결합도가 높아지며, 유연성은 떨어진다.

• 외부 라이브러리를 정확히 이해하지 못했다면 사용하지 않는 것이 낫다.
• 상속은 is-a 관계에 한정해 적용하는 것이 올바르다.
• 라이브러리 내에 얼마나 많은 메서드가 있는지 알 수 없다.

from _adapter_base import UsernameLookup

class UserSource:
	def __init__(self):
        self.username_lookup = UsernameLookup()	

	def fetch(self, user_id, username):
		user_namespace = self._adapt_arguments(user_id, username)
		return self.username_lookup.search(user_namespace)

	@staticmethod
	def _adapt_arguments(user_id, username):
		return f"{user_id}:{username}"

여러 메서드에서 이와 같은 작업을 해야 한다면,

• __getattr__ 사용
• UserSource 클래스는 UsernameLookup의 프록시 또는 래퍼 역할을 하게 된다.
• UserSource 클래스에서 UsernameLookup 클래스의 어떤 메서드에도 직접적으로 접근하지 않는다.
• 모든 메서드 호출을 UsernameLookup 인스턴스로 자동으로 전달할 수 있다.
• 너무 일반적이라 위험하고, 예상치 못한 부작용이 있을 수 있다.

• 데코레이터 사용
• 함수나 메서드를 감싸는 래퍼(wrapper) 함수 역할
• 기존 코드를 변경하지 않고, 객체에 추가 기능을 동적으로 추가할 수 있게 하는 디자인 패턴
• __getattr__과 비교해서 오류를 추적하고 디버깅하기가 더 쉽다
• 특정 함수나 메서드에 대한 변경을 격리하여, 전체 클래스에 미치는 영향을 최소화한다. __getattr__을 사용할 때보다 예상치 못한 부작용의 리스크를 줄일 수 있다.

컴포지트(composite)

class Product:
	def __init__(self, name: str, price: float) -> None:
		self._name = name
		self._price = price

	@property
	def price(self) -> float:
		return self._price

class ProductBundle:
	def __init__(
		self,
		name: str,
		perc_discount: float,
		*products: Iterable[Union[Product, "ProductBundle"]]
	) -> None:
		self._name = name,
		self._perc_discount = perc_discount,
		self._products = products

	@property
	def price(self) -> float:
		total = sum(p.price for p in self._products)
		return total * (1 - self._perc_discount)

# 개별 상품 생성
product1 = Product("Laptop", 1000)
product2 = Product("Phone", 500)

# 상품 묶음 생성
bundle1 = ProductBundle("Electronics Pack", 0.1, product1, product2)

# 또 다른 상품과 상품 묶음 생성
product3 = Product("Tablet", 300)
bundle2 = ProductBundle("Super Pack", 0.15, bundle1, product3)

데코레이터

• Component(구성요소): 원래 객체의 인터페이스를 정의합니다.

• ConcreteComponent(구체적 구성요소): Component를 구현하는 클래스로, 추가될 새로운 기능이 없는 기본 객체이다.

• Decorator(데코레이터): Component와 동일한 인터페이스를 가지며, 하나 이상의 Component(ConcreteComponent 또는 다른 Decorator)를 포함한다.

• ConcreteDecorator(구체적 데코레이터): Decorator를 구현하는 클래스로, Component에 추가 기능을 더한다.

class DictQuery: # Component, ConcreteComponent
	def __init__(self, **kwargs):
		self._raw_query = kwargs

	def render(self) -> None: # 기본 인터페이스를 정의
		return self._raw_query

class QueryEnhancer: # Decorator
	def __init__(self, query: DictQuery):
		self.decorated = query

	def render(self):
		return self.decorated.render()

class RemoveEmpty(QueryEnhancer): # ConcreteDecorator
	def render(self):
		original = super().render()
		return {k: v for k, v in original.items() if v}

class CaseInsensitive(QueryEnhancer): # ConcreteDecorator
	def render(self):
		original = super().render()
		return {k: v.lower() for k, v in original.items()}

>>> original = DictQuery(key="value", empty="", none=None, upper="UPPERCASE", title="Title")
>>> new_query = CaseInsensitive(RemoveEmpty(original))
>>> original.render()
{"key": "value", "empty": "", "none": None, "upper": "UPPERCASE", "title": "Title"}
>>> new_queryset.render()
{"key": "value", "upper": "uppercase", "title": "title"}

파사드(Facade)

class Engine:
    def start(self):
        print("Engine starts!")

class AirConditioner:
    def turn_on(self):
        print("AirConditioner turns on!")

class Radio:
    def play(self):
        print("Radio plays!")

# 파사드를 적용한 클래스
class CarFacade:
    def __init__(self):
        self.engine = Engine()
        self.air_conditioner = AirConditioner()
        self.radio = Radio()

    def start_car(self):
        self.engine.start()
        self.air_conditioner.turn_on()
        self.radio.play()

# 클라이언트 코드
car = CarFacade()
car.start_car()

행동(behavioral) 패턴

책임 연쇄 패턴

import re
from typing import Optional, Pattern

class Event:
	pattern: Optional[Pattern[str]] = None

	def __init__(self, next_event=None):
		self.successor = next_event

	def process(self, logline:str):
		if self.can_process(logline):
			return self._process(logline)

		if self.successor is not None:
			return self.successor.process(logline)

	def _process(self, logline:str) -> dict:
		parsed_data = self._parsed_data(logline)
		return {
			"type": self.__class__.__name__,
			"id": parsed_data["id"],
			"value": parsed_data["value"],
		}

		@classmethod
		def can_process(cls, logline: str) -> bool:
			return (
				cls.pattern is not None and cls.pattern.match(logline) is not None
			)

		@classmethod
		def _parse_data(cls, logline: str) -> dict:
			if not cls.pattern:
				return {}
			if (parsed := cls.pattern.match(logline)) is not None:
				return parsed.groupdict()
			return {}


class LoginEvent(Event):
	pattern = re.compile(r"(?P<id>\d+):\s+login\s+(>P<value>\S+)"

class LogoutEvent(Event):
	pattern = re.compile(r"(?P<id>\d+):\s+logout\s+(>P<value>\S+)"

>>> chain = LogoutEvent(LoginEvent())
>>> chain.process("567: login User")
{"type": "LoginEvent", "id": "567", "value": "User"}

class SessionEvent(Event):
	pattern = re.compile(r"(?P<id>\d+):\s+logout\s+(>P<value>\S+)"

chain = SessionEvent(LoginEvent(LogoutEvent))